home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / src / EvalC2.mi < prev    next >
Text File  |  1992-11-24  |  29KB  |  1,118 lines
  1. IMPLEMENTATION MODULE EvalC2;
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15. IMPORT SYSTEM, System, IO, Tree;
  16. (* line 7 "" *)
  17.  
  18.  
  19. FROM SYSTEM    IMPORT ADR;
  20. FROM IO        IMPORT WriteS, WriteNl, WriteI, StdOutput;
  21. FROM StringMem    IMPORT WriteString;
  22. FROM Idents    IMPORT tIdent, WriteIdent;
  23. FROM Texts    IMPORT WriteText;
  24. FROM Sets    IMPORT tSet, MakeSet, ReleaseSet, Include, Minimum, IsElement, WriteSet;
  25. FROM Relations    IMPORT IsRelated;
  26. FROM TreeC2    IMPORT WriteLine;
  27. FROM EvalC    IMPORT EvalImplHead;
  28.  
  29. FROM Tree    IMPORT
  30.    NoTree    , tTree        , Referenced    , NoCodeClass    ,
  31.    Computed    , Reverse    , Write        , Read        ,
  32.    Inherited    , Synthesized    , Input        , Output    ,
  33.    Stack    , Parameter    , Variable    ,
  34.    CopyDef    , CopyUse    , Thread    , Virtual    ,
  35.    Test        , Left        , Right        , NonBaseComp    ,
  36.    First    , Dummy        , Trace        , ClassCount    ,
  37.    Demand    , Funct        , NoClass    , Options    ,
  38.    TreeRoot    , iModule    , iMain        , itTree    ,
  39.    ForallClasses, ForallAttributes, f        , WI    , WN    ,
  40.    IdentifyAttribute, GrammarClass, cOAG    , MaxVisit    ,
  41.    WriteInstance;
  42.  
  43. VAR
  44.    Start, Stop, Visit, ChildVisit, i, j, k    : SHORTCARD;
  45.    Node, Attr, Class, AttrClass, Child, Child2, ChildsClass    : tTree;
  46.  
  47. PROCEDURE Representative (i: CARDINAL): CARDINAL;    (* Class    *)
  48.    VAR
  49.       s        : tSet;
  50.       r        : CARDINAL;
  51.       Stable    : BOOLEAN;
  52.       j, k    : CARDINAL;
  53.    BEGIN
  54.       WITH Class^.Class DO
  55.      MakeSet (s, InstCount);
  56.      Include (s, i);
  57.      REPEAT
  58.         Stable := TRUE;
  59.         FOR j := 1 TO InstCount DO
  60.            IF IsElement (j, s) THEN
  61.           IF CopyDef IN Instance^[j].Properties THEN
  62.              k := Instance^[j].CopyArg;
  63.              IF (Parameter IN Instance^[k].Attribute^.Attribute.Properties) AND
  64.             NOT IsElement (k, s) THEN
  65.             Include (s, k);
  66.             Stable := FALSE;
  67.              END;
  68.           END;
  69.           IF CopyUse IN Instance^[j].Properties THEN
  70.              FOR k := 1 TO InstCount DO
  71.             IF (CopyDef IN Instance^[k].Properties) AND
  72.                (Parameter IN Instance^[k].Attribute^.Attribute.Properties) AND
  73.                (Instance^[k].CopyArg = j) AND
  74.                NOT IsElement (k, s) THEN
  75.                Include (s, k);
  76.                Stable := FALSE;
  77.             END;
  78.              END;
  79.           END;
  80.            END;
  81.         END;
  82.      UNTIL Stable;
  83.      r := Minimum (s);
  84.      IF r <= AttrCount THEN
  85.         Stable := TRUE;
  86.         j := r + 1;
  87.         LOOP
  88.            IF j > AttrCount THEN EXIT; END;
  89.            IF IsElement (j, s) THEN Stable := FALSE; EXIT; END;
  90.            INC (j);
  91.         END;
  92.         IF NOT Stable THEN
  93.            j := 1;
  94.            LOOP
  95.           k := Instance^ [j].Order;
  96.           IF (k <= AttrCount) AND IsElement (k, s) THEN r := k; EXIT; END;
  97.           INC (j);
  98.            END;
  99.         END;
  100.      END;
  101.      ReleaseSet (s);
  102.      RETURN r;
  103.       END;
  104.    END Representative;
  105.  
  106. PROCEDURE GenAttribute (i: CARDINAL; repr: BOOLEAN);    (* Class = subtype, Node = current type, k    *)
  107.    BEGIN
  108.       IF repr THEN
  109.      WITH Class^.Class.Instance^[i] DO
  110.         IF (Parameter IN Attribute^.Attribute.Properties) AND
  111.            (({CopyDef, CopyUse} * Properties) # {}) THEN
  112.            i := Representative (i);
  113.         END;
  114.      END;
  115.       END;
  116.       WITH Class^.Class.Instance^[i] DO
  117.      IF Virtual IN Properties THEN RETURN; END;
  118.      IF Left IN Properties THEN                    (* left        *)
  119.         WITH Attribute^.Attribute DO
  120.            IF Parameter IN Properties THEN
  121.           IF IdentifyAttribute (Node, Name) = NoTree THEN
  122.              WriteS (f, "yy"); WI (Name);                    (* local    *)
  123.           ELSE
  124.              WriteS (f, "(* yy"); WI (Name); WriteS (f, ")");                (* param    *)
  125.           END;
  126.            ELSIF Demand IN Properties THEN                (* demand    *)
  127.           IF Funct IN Properties THEN
  128.              AttrClass := GetClass (Class, Name);        (* function    *)
  129.              WriteS (f, "y"); WI (AttrClass^.Class.Name); WriteS (f, "y"); WI (Name); WriteS (f, " (yyt)"); 
  130.           ELSIF i # k THEN
  131.              WriteS (f, "yy"); WI (Name);                    (* local    *)
  132.           ELSE
  133.              WriteS (f, "(* yy"); WI (Name); WriteS (f, ")");                (* param    *)
  134.           END;
  135.            ELSE                            (* tree        *)
  136.           WriteS (f, "yyt->"); WI (Class^.Class.Name); WriteS (f, "."); WI (Name);
  137.            END;
  138.         END;
  139.      ELSE                                (* right    *)
  140.         WITH Attribute^.Attribute DO
  141.            IF Parameter IN Properties THEN
  142.           WI (Selector^.Child.Name); WriteS (f, "yy"); WI (Name);        (* param    *)
  143.            ELSIF Demand IN Properties THEN                (* demand    *)
  144.           IF Funct IN Properties THEN            (* function    *)
  145.              AttrClass := GetClass (Selector^.Child.Class, Name);
  146.              WriteS (f, "y"); WI (AttrClass^.Class.Name); WriteS (f, "y"); WI (Name);
  147.              WriteS (f, " (yyt->"); WI (Class^.Class.Name); WriteS (f, "."); WI (Selector^.Child.Name); WriteS (f, ")"); 
  148.           ELSE
  149.              WI (Selector^.Child.Name); WriteS (f, "yy"); WI (Name);
  150.           END;
  151.            ELSE                            (* tree        *)
  152.           WriteS (f, "yyt->"); WI (Class^.Class.Name); WriteS (f, "."); WI (Selector^.Child.Name);
  153.           WriteS (f, "->"); WI (Selector^.Child.Type); WriteS (f, "."); WI (Name);
  154.            END;
  155.         END;
  156.      END;
  157.       END;
  158.    END GenAttribute;
  159.  
  160. PROCEDURE GetClass (Class: tTree; Attribute: tIdent): tTree;
  161.    BEGIN
  162.       WHILE Class^.Kind # NoClass DO
  163.      IF IdentifyAttribute (Class^.Class.Attributes, Attribute) # NoTree THEN RETURN Class; END;
  164.      Class := Class^.Class.BaseClass;
  165.       END;
  166.       RETURN NoTree;
  167.    END GetClass;
  168.  
  169. PROCEDURE CheckUsage (Usage: BITSET): BOOLEAN;    (* Class, Child, Start, Stop    *)
  170.    VAR i, i2: SHORTCARD;
  171.    BEGIN
  172.       FOR i := Start TO Stop DO
  173.      i2 := Class^.Class.Instance^ [i].Order;
  174.      WITH Class^.Class.Instance^ [i2] DO
  175.         IF ({Synthesized, Right, First} <= Properties) AND
  176.            (Child = Selector) AND
  177.            (Attribute^.Child.Partition <= Selector^.Child.Class^.Class.Visits) AND
  178.            (Attribute^.Child.Partition IN Usage) THEN
  179.            RETURN TRUE;
  180.         END;
  181.         IF ({Inherited, Right} <= Properties) AND (i2 = j) THEN
  182.            RETURN TRUE;
  183.         END;
  184.      END;
  185.       END;
  186.       RETURN FALSE;
  187.    END CheckUsage;
  188.  
  189.  
  190.  
  191.  
  192.  
  193.  
  194.  
  195.  
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203.  
  204.  
  205.  
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.  
  224.  
  225.  
  226.  
  227.  
  228.  
  229.  
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238.  
  239.  
  240.  
  241.  
  242.  
  243.  
  244.  
  245.  
  246.  
  247.  
  248.  
  249.  
  250.  
  251.  
  252.  
  253.  
  254.  
  255.  
  256.  
  257.  
  258.  
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268.  
  269.  
  270.  
  271.  
  272.  
  273.  
  274.  
  275.  
  276.  
  277.  
  278.  
  279.  
  280.  
  281.  
  282.  
  283.  
  284.  
  285.  
  286.  
  287.  
  288. PROCEDURE yyAbort (yyFunction: ARRAY OF CHAR);
  289.  BEGIN
  290.   IO.WriteS (IO.StdError, 'Error: module EvalC2, routine ');
  291.   IO.WriteS (IO.StdError, yyFunction);
  292.   IO.WriteS (IO.StdError, ' failed');
  293.   IO.WriteNl (IO.StdError);
  294.   Exit;
  295.  END yyAbort;
  296.  
  297. PROCEDURE yyIsEqual (yya, yyb: ARRAY OF SYSTEM.BYTE): BOOLEAN;
  298.  VAR yyi    : INTEGER;
  299.  BEGIN
  300.   FOR yyi := 0 TO INTEGER (HIGH (yya)) DO
  301.    IF yya [yyi] # yyb [yyi] THEN RETURN FALSE; END;
  302.   END;
  303.   RETURN TRUE;
  304.  END yyIsEqual;
  305.  
  306. PROCEDURE EvalImplC (t: Tree.tTree);
  307.  VAR yyTempo: RECORD CASE : INTEGER OF
  308.  END; END;
  309.  BEGIN
  310.   IF t = Tree.NoTree THEN RETURN; END;
  311.   IF (t^.Kind = Tree.Ag) THEN
  312. (* line 184 "" *)
  313.      WITH t^.Ag DO
  314. (* line 184 "" *)
  315.       
  316.     EvalImplHead (t);
  317.     WriteNl (f);
  318.     ForallClasses (Classes, Forward);
  319.     WriteNl (f);
  320.     WriteS (f, "void "); WI (EvalName); WriteNl (f);
  321.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  322.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  323.     WriteS (f, "# else"); WriteNl (f);
  324.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  325.     WriteS (f, "# endif"); WriteNl (f);
  326.     Node := Classes;
  327.     Class := Classes;
  328.     WriteS (f, "{"); WriteNl (f);
  329.     ForallAttributes (Class, GenTemposLocal);
  330.       IF NOT IsElement (ORD ('9'), Options) THEN
  331.     IF MaxVisit > 0 THEN
  332.        Class := Classes;
  333.        Visit := 1;
  334.        WriteS (f, " yyVisit1"); WI (Class^.Class.Name); WriteS (f, " (yyt"); 
  335.        ForallAttributes (Class, GenActualsLeft);
  336.        WriteS (f, ");"); 
  337.     END;
  338.     WriteS (f, " }"); WriteNl (f);
  339.       ELSE
  340.     WriteS (f, " char xxHigh;"); WriteNl (f);
  341.     WriteS (f, " xxStack = 1000000000;"); WriteNl (f);
  342.     IF MaxVisit > 0 THEN
  343.        Class := Classes;
  344.        Visit := 1;
  345.        WriteS (f, " yyVisit1"); WI (Class^.Class.Name); WriteS (f, " (yyt"); 
  346.        ForallAttributes (Class, GenActualsLeft);
  347.        WriteS (f, ");"); WriteNl (f);
  348.     END;
  349.     WriteS (f, ' (void) printf ("Stacksize %d\n", (int) & xxHigh - xxStack);'); WriteNl (f);
  350.     WriteS (f, "}"); WriteNl (f);
  351.       END;
  352.     WriteNl (f);
  353.     ForallClasses (Classes, GenDemandProc);
  354.     ForallClasses (Classes, EvalImplC);
  355.     WriteS (f, "void Begin"); WI (EvalName); WriteS (f, " ()"); WriteNl (f);
  356.     WriteS (f, "{"); WriteNl (f);
  357.     WriteLine (EvalCodes^.Codes.BeginLine);
  358.     WriteText (f, EvalCodes^.Codes.Begin);
  359.     Node := Modules;
  360.     WHILE Node^.Kind = Tree.Module DO
  361.        WriteLine (Node^.Module.EvalCodes^.Codes.BeginLine);
  362.        WriteText (f, Node^.Module.EvalCodes^.Codes.Begin);
  363.        Node := Node^.Module.Next;
  364.     END;
  365.     WriteS (f, "}"); WriteNl (f);
  366.     WriteNl (f);
  367.     WriteS (f, "void Close"); WI (EvalName); WriteS (f, " ()"); WriteNl (f);
  368.     WriteS (f, "{"); WriteNl (f);
  369.     WriteLine (EvalCodes^.Codes.CloseLine);
  370.     WriteText (f, EvalCodes^.Codes.Close);
  371.     Node := Modules;
  372.     WHILE Node^.Kind = Tree.Module DO
  373.        WriteLine (Node^.Module.EvalCodes^.Codes.CloseLine);
  374.        WriteText (f, Node^.Module.EvalCodes^.Codes.Close);
  375.        Node := Node^.Module.Next;
  376.     END;
  377.     WriteS (f, "}"); WriteNl (f);
  378. ;
  379.       RETURN;
  380.      END;
  381.  
  382.   END;
  383.   IF (t^.Kind = Tree.Class) THEN
  384. (* line 248 "" *)
  385.      WITH t^.Class DO
  386. (* line 248 "" *)
  387.       
  388.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  389.     IF Referenced IN Properties THEN
  390.        Generated := 0;
  391.        ForallClasses (Extensions, Generated0);
  392.        FOR Visit := 1 TO Visits DO
  393.           Node := t;
  394.           Class := t;
  395.           WriteS (f, "static void yyVisit"); WN (Visit); WI (Name); WriteNl (f);
  396.           WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  397.           WriteS (f, " (register "); WI (itTree); WriteS (f, " yyt"); ForallAttributes (t, GenFormals3); WriteS (f, ")"); WriteNl (f);
  398.           WriteS (f, "# else"); WriteNl (f);
  399.           WriteS (f, " (yyt"); ForallAttributes (t, GenFormals1); WriteS (f, ")"); WriteNl (f);
  400.           WriteS (f, " register "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  401.           ForallAttributes (t, GenFormals2);
  402.           WriteS (f, "# endif"); WriteNl (f);
  403.           WriteS (f, "{"); WriteNl (f);
  404.           WriteLine (TreeRoot^.Ag.EvalCodes^.Codes.LocalLine);
  405.           WriteText (f, TreeRoot^.Ag.EvalCodes^.Codes.Local);
  406.           Node := TreeRoot^.Ag.Modules;
  407.           WHILE Node^.Kind = Tree.Module DO
  408.          WriteLine (Node^.Module.EvalCodes^.Codes.LocalLine);
  409.          WriteText (f, Node^.Module.EvalCodes^.Codes.Local);
  410.          Node := Node^.Module.Next;
  411.           END;
  412.       IF IsElement (ORD ('9'), Options) THEN
  413.           WriteS (f, " char xxLow;"); WriteNl (f);
  414.           WriteS (f, " xxStack = Min (xxStack, (int) & xxLow);"); WriteNl (f);
  415.       END;
  416.           WriteS (f, " switch (yyt->Kind) {"); WriteNl (f);
  417.           IF cOAG IN GrammarClass THEN        (* generate evaluator    *)
  418.          Node := t;
  419.          GenEvaluator (t);
  420.          ForallClasses (Extensions, GenEvaluator);
  421.           END;
  422.           WriteS (f, " default: ;"); WriteNl (f);
  423.       IF IsElement (ORD ('Z'), Options) THEN
  424.           WriteS (f, "  yyVisitParent (yyt);"); WriteNl (f);
  425.       END;
  426.           WriteS (f, " }"); WriteNl (f);
  427.           WriteS (f, "}"); WriteNl (f);
  428.           WriteNl (f);
  429.        END;
  430.     END;
  431. ;
  432.       RETURN;
  433.      END;
  434.  
  435.   END;
  436.  END EvalImplC;
  437.  
  438. PROCEDURE TypeName (t: Tree.tTree);
  439.  VAR yyTempo: RECORD CASE : INTEGER OF
  440.  END; END;
  441.  BEGIN
  442.   IF t = Tree.NoTree THEN RETURN; END;
  443.   IF (t^.Kind = Tree.Class) THEN
  444. (* line 297 "" *)
  445.      WITH t^.Class DO
  446. (* line 297 "" *)
  447.       
  448.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  449.     IF Trace IN Properties THEN
  450.        WriteS (f, '"'); WI (Name); WriteS (f, '",'); WriteNl (f);
  451.     END;
  452. ;
  453.       RETURN;
  454.      END;
  455.  
  456.   END;
  457.  END TypeName;
  458.  
  459. PROCEDURE Forward (t: Tree.tTree);
  460.  VAR yyTempo: RECORD CASE : INTEGER OF
  461.  END; END;
  462.  BEGIN
  463.   IF t = Tree.NoTree THEN RETURN; END;
  464.   IF (t^.Kind = Tree.Class) THEN
  465. (* line 307 "" *)
  466.      WITH t^.Class DO
  467. (* line 307 "" *)
  468.       
  469.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  470.     IF Referenced IN Properties THEN
  471.        FOR Visit := 1 TO Visits DO
  472.           WriteS (f, "static void yyVisit"); WN (Visit); WI (Name); WriteS (f, " ARGS((register "); WI (itTree); WriteS (f, " yyt"); 
  473.           Node := t;
  474.           Class := t;
  475.           ForallAttributes (t, Forward);
  476.           WriteS (f, "));"); WriteNl (f);
  477.        END;
  478.     END;
  479. ;
  480.       RETURN;
  481.      END;
  482.  
  483.   END;
  484.   IF (t^.Kind = Tree.Attribute) THEN
  485. (* line 319 "" *)
  486.      WITH t^.Attribute DO
  487. (* line 319 "" *)
  488.       
  489.     IF (Parameter IN Properties) AND (Visit IN Usage) THEN
  490.        WriteS (f, ", "); WI (Type); WriteS (f, " "); GenAttribute (AttrIndex, FALSE);
  491.     END;
  492. ;
  493.       RETURN;
  494.      END;
  495.  
  496.   END;
  497.  END Forward;
  498.  
  499. PROCEDURE GenEvaluator (t: Tree.tTree);
  500.  VAR yyTempo: RECORD CASE : INTEGER OF
  501.  END; END;
  502.  BEGIN
  503.   IF t = Tree.NoTree THEN RETURN; END;
  504.  
  505.   CASE t^.Kind OF
  506.   | Tree.Class:
  507. (* line 328 "" *)
  508.      WITH t^.Class DO
  509. (* line 328 "" *)
  510.       
  511.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  512.     IF Generated = InstCount THEN RETURN; END;
  513.     WriteS (f, "case k"); WI (Name); WriteS (f, ": {"); WriteNl (f);
  514.  
  515.     Start := Generated + 1;
  516.     LOOP
  517.        IF Generated = InstCount THEN EXIT; END;
  518.        INC (Generated);
  519.        WITH Instance^ [Instance^ [Generated].Order] DO
  520.           IF (Left IN Properties) AND (Attribute^.Child.Partition > Visit) THEN
  521.              DEC (Generated); EXIT;
  522.           END;
  523.        END;
  524.     END;
  525.     Stop := Generated;
  526.  
  527.     Class := t;
  528.     ForallAttributes (t, GenTempos);
  529.  
  530.     FOR Start := Start TO Stop DO
  531.        i := Instance^ [Start].Order;
  532.        WITH Instance^ [i] DO
  533.           IF ({Inherited, Right, First} <= Properties) AND ({Dummy, Virtual, Demand} * Properties = {}) THEN
  534.          GenDemandEval (t);
  535.       IF IsElement (ORD ('X'), Options) AND (Trace IN t^.Class.Properties) THEN
  536.          WriteS (f, 'yyWriteEval (yyt, "'); WI (Selector^.Child.Name); WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, '");'); WriteNl (f);
  537.          IF Action # ADR (Action) THEN GenEvaluator (Action); END; WriteNl (f);
  538.          IF (Attribute^.Kind = Tree.Child) OR (Attribute^.Attribute.Type = itTree) THEN
  539.             WriteS (f, "write"); WI (itTree); WriteS (f, " ("); GenAttribute (i, TRUE); WriteS (f, ")"); WriteNl (f);
  540.          ELSE
  541.             WriteS (f, "write"); WI (Attribute^.Child.Type); WriteS (f, " ("); GenAttribute (i, TRUE); WriteS (f, ") yyWriteNl ();"); WriteNl (f);
  542.          END;
  543.       ELSIF IsElement (ORD ('Y'), Options) AND (Trace IN t^.Class.Properties) THEN
  544.          WriteS (f, 'yyWriteEval (yyt, "'); WI (Selector^.Child.Name); WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, '");'); WriteNl (f);
  545.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  546.       ELSE
  547.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  548.       END;
  549.           END;
  550.           IF ({Synthesized, Left, First} <= Properties) AND ({Dummy, Virtual, Demand} * Properties = {}) THEN
  551.          GenDemandEval (t);
  552.       IF IsElement (ORD ('X'), Options) AND (Trace IN t^.Class.Properties) THEN
  553.          WriteS (f, 'yyWriteEval (yyt, "'); WI (Attribute^.Child.Name); WriteS (f, '");'); WriteNl (f);
  554.          IF Action # ADR (Action) THEN GenEvaluator (Action); END; WriteNl (f);
  555.          IF Test IN Properties THEN
  556.             WriteS (f, "writebool (yyb) yyWriteNl ();"); WriteNl (f);
  557.          ELSIF (Attribute^.Kind = Tree.Child) OR (Attribute^.Attribute.Type = itTree) THEN
  558.             WriteS (f, "write"); WI (itTree); WriteS (f, " ("); GenAttribute (i, TRUE); WriteS (f, ")"); WriteNl (f);
  559.          ELSE
  560.             WriteS (f, "write"); WI (Attribute^.Child.Type); WriteS (f, " ("); GenAttribute (i, TRUE); WriteS (f, ") yyWriteNl ();"); WriteNl (f);
  561.          END;
  562.       ELSIF IsElement (ORD ('Y'), Options) AND (Trace IN t^.Class.Properties) THEN
  563.          WriteS (f, 'yyWriteEval (yyt, "'); WI (Attribute^.Child.Name); WriteS (f, '");'); WriteNl (f);
  564.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  565.       ELSE
  566.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  567.       END;
  568.           END;
  569.           IF ({Synthesized, Right, First} <= Properties) AND
  570.          (Attribute^.Child.Partition <= Selector^.Child.Class^.Class.Visits) THEN
  571.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  572.          WriteS (f, 'yyWriteVisit (yyt, "'); WI (Selector^.Child.Name); WriteS (f, " "); 
  573.          WN (Attribute^.Child.Partition); WriteS (f, '");'); WriteNl (f);
  574.       END;
  575.          ChildVisit := Attribute^.Child.Partition;
  576.          Child := Selector;
  577.          WriteS (f, "yyVisit"); WN (ChildVisit); WI (Child^.Child.Type);
  578.          WriteS (f, " (yyt->"); WI (Name); WriteS (f, "."); WI (Child^.Child.Name);
  579.          ForallAttributes (Child^.Child.Class, GenActualsRight);
  580.          WriteS (f, ");"); WriteNl (f);
  581.           END;
  582.        END;
  583.     END;
  584.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  585.     WriteS (f, "yyVisitParent (yyt);"); WriteNl (f);
  586.       END;
  587.     WriteS (f, "} break;"); WriteNl (f);
  588. ;
  589.       RETURN;
  590.      END;
  591.  
  592.   | Tree.Assign:
  593. (* line 407 "" *)
  594.      WITH t^.Assign DO
  595. (* line 407 "" *)
  596.       
  597.     WriteLine (Pos);
  598.     GenEvaluator (Results); WriteS (f, "="); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  599. ;
  600.       RETURN;
  601.      END;
  602.  
  603.   | Tree.Copy:
  604. (* line 411 "" *)
  605.      WITH t^.Copy DO
  606. (* line 411 "" *)
  607.       
  608.     j := Class^.Class.Instance^[i].CopyArg;
  609.     IF (Parameter IN Class^.Class.Instance^[i].Attribute^.Attribute.Properties) AND
  610.        (Parameter IN Class^.Class.Instance^[j].Attribute^.Attribute.Properties) THEN
  611.        IF (Left IN Class^.Class.Instance^[i].Properties) AND
  612.           (Left IN Class^.Class.Instance^[j].Properties) THEN
  613.  
  614.           WriteLine (Pos);
  615.           GenAttribute (i, FALSE); WriteS (f, " ="); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  616.        END;
  617.     ELSE
  618.        WriteLine (Pos);
  619.        GenEvaluator (Results); WriteS (f, "="); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  620.     END;
  621. ;
  622.       RETURN;
  623.      END;
  624.  
  625.   | Tree.TargetCode:
  626. (* line 426 "" *)
  627.      WITH t^.TargetCode DO
  628. (* line 426 "" *)
  629.       
  630.     WriteLine (Pos);
  631.     GenEvaluator (Code); WriteNl (f);
  632. ;
  633.       RETURN;
  634.      END;
  635.  
  636.   | Tree.Check:
  637. (* line 430 "" *)
  638.      WITH t^.Check DO
  639. (* line 430 "" *)
  640.       
  641.     WriteLine (Pos);
  642.     IF Condition # NoTree THEN
  643.        WriteS (f, 'if (! ('); 
  644.       IF IsElement (ORD ('X'), Options) THEN
  645.        WriteS (f, "yyb = "); 
  646.       END;
  647.        GenEvaluator (Condition); WriteS (f, ")) {"); GenEvaluator (Statement); WriteS (f, "; }"); WriteNl (f);
  648.        IF Actions^.Kind = Tree.Check THEN
  649.           WriteS (f, "else "); GenEvaluator (Actions);
  650.        END;
  651.     ELSE
  652.       IF IsElement (ORD ('X'), Options) THEN
  653.        WriteS (f, "yyb = false; "); 
  654.       END;
  655.        GenEvaluator (Statement); WriteS (f, ";"); WriteNl (f);
  656.        GenEvaluator (Actions);
  657.     END;
  658. ;
  659.       RETURN;
  660.      END;
  661.  
  662.   | Tree.Designator:
  663. (* line 449 "" *)
  664.      WITH t^.Designator DO
  665. (* line 449 "" *)
  666.       
  667.     Child2 := IdentifyAttribute (Class, Selector);
  668.     IF Child2 # NoTree THEN
  669.        ChildsClass := Child2^.Child.Class;
  670.        Attr := IdentifyAttribute (ChildsClass, Attribute);
  671.        IF Attr # NoTree THEN
  672.           GenAttribute (Class^.Class.AttrCount + Child2^.Child.InstOffset + Attr^.Attribute.AttrIndex, TRUE);
  673.        ELSE
  674.           WI (Selector); WriteS (f, ":"); WI (Attribute);
  675.        END;
  676.     ELSE
  677.        WI (Selector); WriteS (f, ":"); WI (Attribute);
  678.     END;
  679.     GenEvaluator (Next);
  680. ;
  681.       RETURN;
  682.      END;
  683.  
  684.   | Tree.Ident:
  685. (* line 464 "" *)
  686.      WITH t^.Ident DO
  687. (* line 464 "" *)
  688.       
  689.     Attr := IdentifyAttribute (Class, Attribute);
  690.     IF Attr # NoTree THEN
  691.        GenAttribute (Attr^.Attribute.AttrIndex, TRUE);
  692.     ELSE
  693.        WI (Attribute);
  694.     END;
  695.     GenEvaluator (Next);
  696. ;
  697.       RETURN;
  698.      END;
  699.  
  700.   | Tree.Any:
  701. (* line 473 "" *)
  702.      WITH t^.Any DO
  703. (* line 473 "" *)
  704.       
  705.     WriteString (f, Code);
  706.     GenEvaluator (Next);
  707. ;
  708.       RETURN;
  709.      END;
  710.  
  711.   | Tree.Anys:
  712. (* line 477 "" *)
  713.      WITH t^.Anys DO
  714. (* line 477 "" *)
  715.       
  716.     GenEvaluator (Layouts);
  717.     GenEvaluator (Next);
  718. ;
  719.       RETURN;
  720.      END;
  721.  
  722.   | Tree.LayoutAny:
  723. (* line 481 "" *)
  724.      WITH t^.LayoutAny DO
  725. (* line 481 "" *)
  726.       
  727.     WriteString (f, Code);
  728.     GenEvaluator (Next);
  729. ;
  730.       RETURN;
  731.      END;
  732.  
  733.   ELSE END;
  734.  
  735.  END GenEvaluator;
  736.  
  737. PROCEDURE Generated0 (t: Tree.tTree);
  738.  VAR yyTempo: RECORD CASE : INTEGER OF
  739.  END; END;
  740.  BEGIN
  741.   IF t = Tree.NoTree THEN RETURN; END;
  742.   IF (t^.Kind = Tree.Class) THEN
  743. (* line 489 "" *)
  744.      WITH t^.Class DO
  745. (* line 489 "" *)
  746.       
  747.     Generated := 0;
  748. ;
  749.       RETURN;
  750.      END;
  751.  
  752.   END;
  753.  END Generated0;
  754.  
  755. PROCEDURE GenFormals1 (t: Tree.tTree);
  756.  VAR yyTempo: RECORD CASE : INTEGER OF
  757.  END; END;
  758.  BEGIN
  759.   IF t = Tree.NoTree THEN RETURN; END;
  760.   IF (t^.Kind = Tree.Attribute) THEN
  761. (* line 496 "" *)
  762.      WITH t^.Attribute DO
  763. (* line 496 "" *)
  764.       
  765.     IF (Parameter IN Properties) AND (Visit IN Usage) THEN
  766.        WriteS (f, ", yy"); WI (Name);
  767.     END;
  768. ;
  769.       RETURN;
  770.      END;
  771.  
  772.   END;
  773.  END GenFormals1;
  774.  
  775. PROCEDURE GenFormals2 (t: Tree.tTree);
  776.  VAR yyTempo: RECORD CASE : INTEGER OF
  777.  END; END;
  778.  BEGIN
  779.   IF t = Tree.NoTree THEN RETURN; END;
  780.   IF (t^.Kind = Tree.Attribute) THEN
  781. (* line 505 "" *)
  782.      WITH t^.Attribute DO
  783. (* line 505 "" *)
  784.       
  785.     IF (Parameter IN Properties) AND (Visit IN Usage) THEN
  786.        WriteS (f, " "); WI (Type); WriteS (f, " "); GenAttribute (AttrIndex, FALSE); WriteS (f, ";"); WriteNl (f);
  787.     END;
  788. ;
  789.       RETURN;
  790.      END;
  791.  
  792.   END;
  793.  END GenFormals2;
  794.  
  795. PROCEDURE GenFormals3 (t: Tree.tTree);
  796.  VAR yyTempo: RECORD CASE : INTEGER OF
  797.  END; END;
  798.  BEGIN
  799.   IF t = Tree.NoTree THEN RETURN; END;
  800.   IF (t^.Kind = Tree.Attribute) THEN
  801. (* line 514 "" *)
  802.      WITH t^.Attribute DO
  803. (* line 514 "" *)
  804.       
  805.     IF (Parameter IN Properties) AND (Visit IN Usage) THEN
  806.        WriteS (f, " ,"); WI (Type); WriteS (f, " "); GenAttribute (AttrIndex, FALSE);
  807.     END;
  808. ;
  809.       RETURN;
  810.      END;
  811.  
  812.   END;
  813.  END GenFormals3;
  814.  
  815. PROCEDURE GenActualsRight (t: Tree.tTree);
  816.  VAR yyTempo: RECORD CASE : INTEGER OF
  817.  END; END;
  818.  BEGIN
  819.   IF t = Tree.NoTree THEN RETURN; END;
  820.   IF (t^.Kind = Tree.Attribute) THEN
  821. (* line 523 "" *)
  822.      WITH t^.Attribute DO
  823. (* line 523 "" *)
  824.       
  825.     IF (Parameter IN Properties) AND (ChildVisit IN Usage) THEN
  826.        WriteS (f, ", & "); GenAttribute (Class^.Class.AttrCount + Child^.Child.InstOffset + AttrIndex, TRUE);
  827.     END;
  828. ;
  829.       RETURN;
  830.      END;
  831.  
  832.   END;
  833.  END GenActualsRight;
  834.  
  835. PROCEDURE GenActualsLeft (t: Tree.tTree);
  836.  VAR yyTempo: RECORD CASE : INTEGER OF
  837.  END; END;
  838.  BEGIN
  839.   IF t = Tree.NoTree THEN RETURN; END;
  840.   IF (t^.Kind = Tree.Attribute) THEN
  841. (* line 532 "" *)
  842.      WITH t^.Attribute DO
  843. (* line 532 "" *)
  844.       
  845.     IF (Parameter IN Properties) AND (Visit IN Usage) THEN
  846.        WriteS (f, ", "); GenAttribute (AttrIndex, FALSE);
  847.     END;
  848. ;
  849.       RETURN;
  850.      END;
  851.  
  852.   END;
  853.  END GenActualsLeft;
  854.  
  855. PROCEDURE GenTempos (t: Tree.tTree);
  856.  VAR yyTempo: RECORD CASE : INTEGER OF
  857.  END; END;
  858.  BEGIN
  859.   IF t = Tree.NoTree THEN RETURN; END;
  860.   IF (t^.Kind = Tree.Child) THEN
  861. (* line 541 "" *)
  862.      WITH t^.Child DO
  863. (* line 541 "" *)
  864.       
  865.     Child := t;
  866.     ForallAttributes (Class, GenTemposChildren);
  867. ;
  868.       RETURN;
  869.      END;
  870.  
  871.   END;
  872.   IF (t^.Kind = Tree.Attribute) THEN
  873. (* line 545 "" *)
  874.      WITH t^.Attribute DO
  875. (* line 545 "" *)
  876.       
  877.     IF (Parameter IN Properties) AND (IdentifyAttribute (Node, Name) = NoTree) AND (Visit IN Usage) OR
  878.        (Demand IN Properties) AND NOT (Funct IN Properties) AND (AttrIndex # k) THEN
  879.        WI (Type); WriteS (f, " yy"); WI (Name); WriteS (f, ";"); WriteNl (f);
  880.     END;
  881. ;
  882.       RETURN;
  883.      END;
  884.  
  885.   END;
  886.  END GenTempos;
  887.  
  888. PROCEDURE GenTemposChildren (t: Tree.tTree);
  889.  VAR yyTempo: RECORD CASE : INTEGER OF
  890.  END; END;
  891.  BEGIN
  892.   IF t = Tree.NoTree THEN RETURN; END;
  893.   IF (t^.Kind = Tree.Attribute) THEN
  894. (* line 555 "" *)
  895.      WITH t^.Attribute DO
  896. (* line 555 "" *)
  897.       
  898.     IF (Parameter IN Properties) OR
  899.        (Demand IN Properties) AND NOT (Funct IN Properties) THEN
  900.        j := Class^.Class.AttrCount + Child^.Child.InstOffset + AttrIndex;
  901.        IF (Demand IN Properties) OR
  902.           (({CopyDef, CopyUse} * Class^.Class.Instance^[j].Properties) = {}) OR
  903.           (j = Representative (j)) THEN
  904.           IF CheckUsage (Usage) THEN
  905.          WI (Type); WriteS (f, " "); WI (Child^.Child.Name); WriteS (f, "yy"); WI (Name); WriteS (f, ";"); WriteNl (f);
  906.           END;
  907.        END;
  908.     END;
  909. ;
  910.       RETURN;
  911.      END;
  912.  
  913.   END;
  914.  END GenTemposChildren;
  915.  
  916. PROCEDURE GenTemposLocal (t: Tree.tTree);
  917.  VAR yyTempo: RECORD CASE : INTEGER OF
  918.  END; END;
  919.  BEGIN
  920.   IF t = Tree.NoTree THEN RETURN; END;
  921.   IF (t^.Kind = Tree.Attribute) THEN
  922. (* line 572 "" *)
  923.      WITH t^.Attribute DO
  924. (* line 572 "" *)
  925.       
  926.     IF Parameter IN Properties THEN
  927.        WriteS (f, "  "); WI (Type); WriteS (f, " "); GenAttribute (AttrIndex, FALSE); WriteS (f, ";"); WriteNl (f);
  928.     END;
  929. ;
  930.       RETURN;
  931.      END;
  932.  
  933.   END;
  934.  END GenTemposLocal;
  935.  
  936. PROCEDURE GenDemandProc (t: Tree.tTree);
  937.  VAR yyTempo: RECORD CASE : INTEGER OF
  938.  END; END;
  939.  BEGIN
  940.   IF t = Tree.NoTree THEN RETURN; END;
  941.   IF (t^.Kind = Tree.Class) THEN
  942. (* line 581 "" *)
  943.      WITH t^.Class DO
  944. (* line 581 "" *)
  945.       
  946.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  947.     Node := t;
  948.     ForallAttributes (Attributes, GenDemandProc);
  949. ;
  950.       RETURN;
  951.      END;
  952.  
  953.   END;
  954.   IF (t^.Kind = Tree.Attribute) THEN
  955. (* line 586 "" *)
  956.      WITH t^.Attribute DO
  957. (* line 586 "" *)
  958.       
  959.     IF Demand IN Properties THEN
  960.        Class := Node;
  961.        k := AttrIndex;
  962.        IF Funct IN Properties THEN
  963.           WriteS (f, "static "); WI (Type); WriteS (f, " y"); WI (Class^.Class.Name); WriteS (f, "y"); WI (Name); WriteNl (f);
  964.           WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  965.           WriteS (f, " (register "); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  966.           WriteS (f, "# else"); WriteNl (f);
  967.           WriteS (f, " (yyt) register "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  968.           WriteS (f, "# endif"); WriteNl (f);
  969.        ELSE
  970.           WriteS (f, "static void y"); WI (Class^.Class.Name); WriteS (f, "y"); WI (Name); WriteNl (f);
  971.           WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  972.           WriteS (f, " (register "); WI (itTree); WriteS (f, " yyt, "); WI (Type); WriteS (f, " * "); GenAttribute (AttrIndex, FALSE); WriteS (f, ")"); WriteNl (f);
  973.           WriteS (f, "# else"); WriteNl (f);
  974.           WriteS (f, " (yyt, "); GenAttribute (AttrIndex, FALSE); WriteS (f, ")"); WriteNl (f);
  975.           WriteS (f, " register "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  976.           WriteS (f, " "); WI (Type); WriteS (f, " * "); GenAttribute (AttrIndex, FALSE); WriteS (f, ";"); WriteNl (f);
  977.           WriteS (f, "# endif"); WriteNl (f);
  978.        END;
  979.        WriteS (f, "{"); WriteNl (f);
  980.        WriteS (f, " switch (yyt->Kind) {"); WriteNl (f);
  981.        IF cOAG IN GrammarClass THEN
  982.           i := AttrIndex;
  983.           Class := Node;
  984.           Visit := Partition;
  985.           GenDemandProc2 (Class);
  986.           ForallClasses (Class^.Class.Extensions, GenDemandProc2);
  987.           Class := Node;
  988.        END;
  989.        WriteS (f, " default: ;"); WriteNl (f);
  990.        WriteS (f, " }"); WriteNl (f);
  991.        WriteS (f, "}"); WriteNl (f);
  992.        WriteNl (f);
  993.        k := 0;
  994.     END;
  995. ;
  996.       RETURN;
  997.      END;
  998.  
  999.   END;
  1000.  END GenDemandProc;
  1001.  
  1002. PROCEDURE GenDemandProc2 (t: Tree.tTree);
  1003.  VAR yyTempo: RECORD CASE : INTEGER OF
  1004.  END; END;
  1005.  BEGIN
  1006.   IF t = Tree.NoTree THEN RETURN; END;
  1007.   IF (t^.Kind = Tree.Class) THEN
  1008. (* line 628 "" *)
  1009.      WITH t^.Class DO
  1010. (* line 628 "" *)
  1011.       
  1012.     WriteS (f, "case k"); WI (Name); WriteS (f, ": {"); WriteNl (f);
  1013.     WITH Instance^ [i] DO
  1014.        Class := t;
  1015.        ForallAttributes (t, GenTempos);
  1016.        GenDemandEval (t);
  1017.        IF Funct IN Properties THEN
  1018.           GenDemandProc2 (Action);
  1019.        ELSE
  1020.           GenEvaluator (Action); WriteNl (f);
  1021.        END;
  1022.     END;
  1023.     WriteS (f, "} break;"); WriteNl (f);
  1024. ;
  1025.       RETURN;
  1026.      END;
  1027.  
  1028.   END;
  1029.   IF (t^.Kind = Tree.Assign) THEN
  1030. (* line 642 "" *)
  1031.      WITH t^.Assign DO
  1032. (* line 642 "" *)
  1033.       
  1034.     WriteS (f, "return "); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  1035. ;
  1036.       RETURN;
  1037.      END;
  1038.  
  1039.   END;
  1040.   IF (t^.Kind = Tree.Copy) THEN
  1041. (* line 645 "" *)
  1042.      WITH t^.Copy DO
  1043. (* line 645 "" *)
  1044.       
  1045.     WriteS (f, "return "); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  1046. ;
  1047.       RETURN;
  1048.      END;
  1049.  
  1050.   END;
  1051.   IF (t^.Kind = Tree.TargetCode) THEN
  1052. (* line 648 "" *)
  1053.      WITH t^.TargetCode DO
  1054. (* line 648 "" *)
  1055.       
  1056.     WriteS (f, "NoBlockStatementForDemandFunctionAttributes;"); WriteNl (f);
  1057. ;
  1058.       RETURN;
  1059.      END;
  1060.  
  1061.   END;
  1062.  END GenDemandProc2;
  1063.  
  1064. PROCEDURE GenDemandEval (t: Tree.tTree);
  1065.  VAR yyTempo: RECORD CASE : INTEGER OF
  1066.  END; END;
  1067.  BEGIN
  1068.   IF t = Tree.NoTree THEN RETURN; END;
  1069.   IF (t^.Kind = Tree.Class) THEN
  1070. (* line 655 "" *)
  1071.      WITH t^.Class DO
  1072. (* line 655 "" *)
  1073.       
  1074.     FOR j := 1 TO InstCount DO
  1075.        WITH Instance^ [j] DO
  1076.           IF IsRelated (i, j, DP) AND 
  1077.          (Demand IN Properties) AND NOT (Funct IN Properties) THEN
  1078.          IF Left IN Properties THEN
  1079.             AttrClass := GetClass (t, Attribute^.Child.Name);
  1080.             WriteS (f, "    y"); WI (AttrClass^.Class.Name); WriteS (f, "y"); WI (Attribute^.Child.Name);
  1081.             WriteS (f, " (yyt, "); GenAttribute (j, FALSE); WriteS (f, ");"); WriteNl (f);
  1082.          ELSE
  1083.             AttrClass := GetClass (Selector^.Child.Class, Attribute^.Child.Name);
  1084.             WriteS (f, "    y"); WI (AttrClass^.Class.Name); WriteS (f, "y"); WI (Attribute^.Child.Name);
  1085.             WriteS (f, " (yyt->"); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name);
  1086.             WriteS (f, ", "); GenAttribute (j, FALSE); WriteS (f, ");"); WriteNl (f);
  1087.          END;
  1088.           END;
  1089.        END;
  1090.     END;
  1091. ;
  1092.       RETURN;
  1093.      END;
  1094.  
  1095.   END;
  1096.  END GenDemandEval;
  1097.  
  1098. PROCEDURE BeginEvalC2;
  1099.  BEGIN
  1100. (* line 180 "" *)
  1101.  k := 0; 
  1102.  END BeginEvalC2;
  1103.  
  1104. PROCEDURE CloseEvalC2;
  1105.  BEGIN
  1106.  END CloseEvalC2;
  1107.  
  1108. PROCEDURE yyExit;
  1109.  BEGIN
  1110.   IO.CloseIO; System.Exit (1);
  1111.  END yyExit;
  1112.  
  1113. BEGIN
  1114.  yyf    := IO.StdOutput;
  1115.  Exit    := yyExit;
  1116.  BeginEvalC2;
  1117. END EvalC2.
  1118.